home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / time / Time_Multiply.c < prev    next >
C/C++ Source or Header  |  1988-06-27  |  3KB  |  111 lines
  1. /* 
  2.  * Time_Multiply.c --
  3.  *
  4.  *    Source code for the Time_Multiply library procedure.
  5.  *
  6.  * Copyright 1988 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15.  
  16. #ifndef lint
  17. static char rcsid[] = "$Header: Time_Multiply.c,v 1.2 88/06/27 17:23:33 ouster Exp $ SPRITE (Berkeley)";
  18. #endif not lint
  19.  
  20. #include <sprite.h>
  21. #include <spriteTime.h>
  22.  
  23. /*
  24.  * OVERFLOW is used to see if multiple precision multiplication
  25.  * and division are required in the Time_Multiply  and Time_Divide routines.
  26.  * The number is equal to (2 ** 31 - 1) / 1000000.
  27.  */
  28.  
  29. #define OVERFLOW 2147
  30.  
  31. /*
  32.  *----------------------------------------------------------------------
  33.  *
  34.  * Time_Multiply --
  35.  *
  36.  *      Computes a multiple of a time value.
  37.  *    E.g. computes a time of 7 seconds given the 
  38.  *    constant time_OneSecond and a factor of 7.
  39.  *
  40.  * Results:
  41.  *     A time.
  42.  *
  43.  * Side effects:
  44.  *     None.
  45.  *
  46.  *----------------------------------------------------------------------
  47.  */
  48.  
  49. void
  50. Time_Multiply(time, factor, resultPtr)
  51.     Time time;
  52.     int     factor;
  53.     Time *resultPtr;
  54. {
  55.     register int    micro;        /* partial result */
  56.     Boolean         normalize;    /* true if normalization necessary. */
  57.  
  58.     /*
  59.      * Since floating point operations are expensive, first check if the 
  60.      * calculation can be done using cheaper integer multiplication. 
  61.      * If there is a possibility of an overflow, then resort to floating point.
  62.      *
  63.      * The test for overflow used below only tests the size of the multiplier.
  64.      * To be fair, it should test the size of time.microseconds too
  65.      * because overflow will not occur if time.microseconds is small.
  66.      * Overflow occurs when numBits(factor) + numBits(time.microseconds) > 31
  67.      * Use the easy test now because at some point in time, this section 
  68.      * should be replaced with double precision integer routines.
  69.      *
  70.      */
  71.  
  72.     normalize = FALSE;
  73.  
  74.     if (factor > OVERFLOW) {
  75.  
  76.     double realProd;
  77.  
  78.     realProd = ((double) time.seconds +
  79.             ((double) time.microseconds / (double) 1000000.0)) *
  80.             (double) factor;
  81.     resultPtr->seconds    = realProd;
  82.     resultPtr->microseconds    = ((realProd - ((double) resultPtr->seconds)) * 
  83.                      1000000.0);
  84.  
  85.     if (resultPtr->microseconds < 0) {
  86.         normalize = TRUE;
  87.     }
  88.     } else {
  89.  
  90.     /*
  91.      *  The microseconds portion is normalized such that it is < 1,000,000.
  92.      */
  93.     micro            = time.microseconds * factor;
  94.     resultPtr->seconds    = (time.seconds * factor) + (micro/ ONE_SECOND);
  95.     resultPtr->microseconds = micro % ONE_SECOND;
  96.  
  97.     if (factor < 0) {
  98.         normalize = TRUE;
  99.     } 
  100.     }
  101.  
  102.     /*
  103.      * Convert to normalized form.
  104.      *
  105.      */
  106.     if (normalize) {
  107.     resultPtr->seconds    -= 1;
  108.     resultPtr->microseconds    += ONE_SECOND;
  109.     } 
  110. }
  111.